home *** CD-ROM | disk | FTP | other *** search
/ Aminet 45 / Aminet 45 (2001)(GTI - Schatztruhe)[!][Oct 2001].iso / Aminet / gfx / x11 / x3270_3_2_16.lha / amiga_src / CmplxMenu.c < prev    next >
C/C++ Source or Header  |  2001-06-23  |  41KB  |  1,405 lines
  1. /* (from) $XConsortium: SimpleMenu.c,v 1.41 92/09/10 16:25:07 converse Exp $ */
  2.  
  3. /*
  4.  * Modifications Copyright 1995, 1999 by Paul Mattes.
  5.  *  Permission to use, copy, modify, and distribute this software and its
  6.  *  documentation for any purpose and without fee is hereby granted,
  7.  *  provided that the above copyright notice appear in all copies and that
  8.  *  both that copyright notice and this permission notice appear in
  9.  *  supporting documentation.
  10.  *
  11.  * Copyright 1989 Massachusetts Institute of Technology
  12.  *
  13.  * Permission to use, copy, modify, distribute, and sell this software and its
  14.  * documentation for any purpose is hereby granted without fee, provided that
  15.  * the above copyright notice appear in all copies and that both that
  16.  * copyright notice and this permission notice appear in supporting
  17.  * documentation, and that the name of M.I.T. not be used in advertising or
  18.  * publicity pertaining to distribution of the software without specific,
  19.  * written prior permission.  M.I.T. makes no representations about the
  20.  * suitability of this software for any purpose.  It is provided "as is"
  21.  * without express or implied warranty.
  22.  *
  23.  * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
  24.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T.
  25.  * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  26.  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  27.  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 
  28.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  29.  */
  30.  
  31. /*
  32.  * ComplexMenu.c - Source code file for ComplexMenu widget.
  33.  * (from) SimpleMenu.c - Source code file for SimpleMenu widget.
  34.  *
  35.  * Date:    April 3, 1989
  36.  *
  37.  * By:      Chris D. Peterson
  38.  *          MIT X Consortium 
  39.  *          kit@expo.lcs.mit.edu
  40.  */
  41.  
  42. #include "globals.h"
  43. #if defined(X3270_MENUS) /*[*/
  44.  
  45. #include <stdio.h>
  46. #include <X11/IntrinsicP.h>
  47. #include <X11/StringDefs.h>
  48.  
  49. #include <X11/Xaw/XawInit.h>
  50. #include "CmplxMenuP.h"
  51. #include "CmeBSB.h"
  52. #include <X11/Xaw/Cardinals.h>
  53. #include <X11/Xaw/MenuButton.h>
  54.  
  55. #include <X11/Xmu/Initer.h>
  56. #include <X11/Xmu/CharSet.h>
  57.  
  58. #include <x11/X.h>
  59. #include <x11/Intrinsic.h>
  60. #include <x11/Shell.h>
  61. #include <x11/ShellP.h>
  62.  
  63. #define streq(a, b)        ( strcmp((a), (b)) == 0 )
  64.  
  65. #define offset(field) XtOffsetOf(ComplexMenuRec, complex_menu.field)
  66.  
  67. static XtResource resources[] = { 
  68.  
  69. /*
  70.  * Label Resources.
  71.  */
  72.  
  73.   {XtNlabel,  XtCLabel, XtRString, sizeof(String),
  74.      offset(label_string), XtRString, NULL},
  75.   {XtNlabelClass,  XtCLabelClass, XtRPointer, sizeof(WidgetClass),
  76.      offset(label_class), XtRImmediate, (XtPointer) NULL},
  77.  
  78. /*
  79.  * Layout Resources.
  80.  */
  81.  
  82.   {XtNrowHeight,  XtCRowHeight, XtRDimension, sizeof(Dimension),
  83.      offset(row_height), XtRImmediate, (XtPointer) 0},
  84.   {XtNtopMargin,  XtCVerticalMargins, XtRDimension, sizeof(Dimension),
  85.      offset(top_margin), XtRImmediate, (XtPointer) 0},
  86.   {XtNbottomMargin,  XtCVerticalMargins, XtRDimension, sizeof(Dimension),
  87.      offset(bottom_margin), XtRImmediate, (XtPointer) 0},
  88.  
  89. /*
  90.  * Misc. Resources
  91.  */
  92.  
  93.   { XtNallowShellResize, XtCAllowShellResize, XtRBoolean, sizeof(Boolean),
  94.       XtOffsetOf(ComplexMenuRec, shell.allow_shell_resize),
  95.       XtRImmediate, (XtPointer) TRUE },
  96.   {XtNcursor, XtCCursor, XtRCursor, sizeof(Cursor),
  97.       offset(cursor), XtRImmediate, (XtPointer) None},
  98.   {XtNmenuOnScreen,  XtCMenuOnScreen, XtRBoolean, sizeof(Boolean),
  99.       offset(menu_on_screen), XtRImmediate, (XtPointer) TRUE},
  100.   {XtNpopupOnEntry,  XtCPopupOnEntry, XtRWidget, sizeof(Widget),
  101.       offset(popup_entry), XtRWidget, NULL},
  102.   {XtNbackingStore, XtCBackingStore, XtRBackingStore, sizeof (int),
  103.       offset(backing_store), 
  104.       XtRImmediate, (XtPointer) (Always + WhenMapped + NotUseful)},
  105.   {XtNcMparent, XtCCMparent, XtRWidget, sizeof(Widget),
  106.       offset(parent), XtRWidget, NULL},
  107.   {XtNcMdefer, XtCCMdefer, XtRWidget, sizeof(Widget),
  108.       offset(deferred_notify), XtRWidget, NULL},
  109. };  
  110. #undef offset
  111.  
  112. static char defaultTranslations[] =
  113.     "<EnterWindow>:     highlight()             \n\
  114.      <LeaveWindow>:     leftWindow()            \n\
  115.      <BtnMotion>:       highlight()             \n\
  116.      <BtnUp>:           saveUnhighlight() MenuPopdown()"; 
  117.  
  118. /*
  119.  * Semi Public function definitions. 
  120.  */
  121.  
  122. static void Redisplay(Widget, XEvent *, Region);
  123. static void Realize(Widget, XtValueMask *, XSetWindowAttributes *);
  124. static void ChangeManaged(Widget);
  125. static void Resize(Widget);
  126. static void Initialize(Widget, Widget, ArgList, Cardinal *);
  127. static void ClassInitialize(void);
  128. static void ClassPartInitialize(WidgetClass);
  129. static Boolean SetValues(Widget, Widget, Widget, ArgList, Cardinal *);
  130. static Boolean SetValuesHook(Widget, ArgList, Cardinal *);
  131. static XtGeometryResult GeometryManager(Widget, XtWidgetGeometry *,
  132.     XtWidgetGeometry *);
  133.  
  134. /*
  135.  * Action Routine Definitions
  136.  */
  137.  
  138. static void PositionMenuAction(Widget, XEvent *, String *, Cardinal *);
  139. static void SaveUnhighlight(Widget, XEvent *, String *, Cardinal *);
  140. static void LeftWindow(Widget, XEvent *, String *, Cardinal *);
  141. static void Highlight(Widget, XEvent *, String *, Cardinal *);
  142.  
  143. /* 
  144.  * Private Function Definitions.
  145.  */
  146.  
  147. static void Unhighlight(), Notify();
  148. static void MakeSetValuesRequest(Widget, Dimension, Dimension);
  149. static void Layout(Widget, Dimension *, Dimension *);
  150. static void CreateLabel(Widget);
  151. static void AddPositionAction(XtAppContext, caddr_t);
  152. static void ChangeCursorOnGrab(Widget, XtPointer junk, XtPointer);
  153. static void PositionMenu(Widget, XPoint *);
  154. static void ClearParent(Widget, XtPointer, XtPointer);
  155. static Dimension GetMenuWidth(Widget, Widget);
  156. static Dimension GetMenuHeight(Widget);
  157. static Widget FindMenu(Widget, String);
  158. static CmeObject GetEventEntry(Widget, XEvent *);
  159. static CmeObject GetRightEntry(Widget, XEvent *);
  160. static void MoveMenu(Widget, Position, Position);
  161.  
  162. static XtActionsRec actionsList[] =
  163. {
  164.   {"highlight",         Highlight},
  165.   {"saveUnhighlight",   SaveUnhighlight},
  166.   {"leftWindow",    LeftWindow},
  167. };
  168.  
  169. static CompositeClassExtensionRec extension_rec = {
  170.     /* next_extension */  NULL,
  171.     /* record_type */     NULLQUARK,
  172.     /* version */         XtCompositeExtensionVersion,
  173.     /* record_size */     sizeof(CompositeClassExtensionRec),
  174.     /* accepts_objects */ TRUE,
  175. };
  176.  
  177. #ifndef AMIGA
  178. #define def_superclass (&overrideShellClassRec)
  179. #else
  180. #define def_superclass (overrideShellWidgetClass)
  181. #endif
  182.     
  183. ComplexMenuClassRec complexMenuClassRec = {
  184.   {
  185.     /* superclass         */    (WidgetClass)0,
  186.     /* class_name         */    "ComplexMenu",
  187.     /* size               */    sizeof(ComplexMenuRec),
  188.     /* class_initialize   */    ClassInitialize,
  189.     /* class_part_initialize*/    ClassPartInitialize,
  190.     /* Class init'ed      */    FALSE,
  191.     /* initialize         */    Initialize,
  192.     /* initialize_hook    */    NULL,
  193.     /* realize            */    Realize,
  194.     /* actions            */    actionsList,
  195.     /* num_actions        */    XtNumber(actionsList),
  196.     /* resources          */    resources,
  197.     /* resource_count     */    XtNumber(resources),
  198.     /* xrm_class          */    NULLQUARK,
  199.     /* compress_motion    */    TRUE, 
  200.     /* compress_exposure  */    TRUE,
  201.     /* compress_enterleave*/     TRUE,
  202.     /* visible_interest   */    FALSE,
  203.     /* destroy            */    NULL,
  204.     /* resize             */    Resize,
  205.     /* expose             */    Redisplay,
  206.     /* set_values         */    SetValues,
  207.     /* set_values_hook    */    SetValuesHook,
  208.     /* set_values_almost  */    0,  
  209.     /* get_values_hook    */    NULL,            
  210.     /* accept_focus       */    NULL,
  211.     /* intrinsics version */    XtVersion,
  212.     /* callback offsets   */    NULL,
  213.     /* tm_table          */    defaultTranslations,
  214.     /* query_geometry      */    NULL,
  215.     /* display_accelerator*/    NULL,
  216.     /* extension      */    NULL
  217.   },{
  218.     /* geometry_manager   */    GeometryManager,
  219.     /* change_managed     */    ChangeManaged,
  220.     /* insert_child      */    0,
  221.     /* delete_child      */    0,
  222.     /* extension      */    NULL
  223.   },{
  224.     /* Shell extension      */    NULL
  225.   },{
  226.     /* Override extension */    NULL
  227.   },{
  228.     /* Complex Menu extension*/  NULL
  229.   }
  230. };
  231.  
  232. WidgetClass complexMenuWidgetClass = (WidgetClass)&complexMenuClassRec;
  233.  
  234. #ifdef AMIGA
  235. void AMIGA_INIT_CMPLXMENU(void)
  236.  {
  237.  complexMenuClassRec.superclass=def_superclass;
  238.  complexMenuClassRec.set_values_almost=XtInheritSetValuesAlmost;
  239.  complexMenuClassRec.insert_child=XtInheritInsertChild;
  240.  complexMenuClassRec.delete_child=XtInheritDeleteChild;
  241.  }
  242. #endif
  243.  
  244. /************************************************************
  245.  *
  246.  * Semi-Public Functions.
  247.  *
  248.  ************************************************************/
  249.  
  250. /*      Function Name: ClassInitialize
  251.  *      Description: Class Initialize routine, called only once.
  252.  *      Arguments: none.
  253.  *      Returns: none.
  254.  */
  255.  
  256. void relay_func(
  257.     XrmValue*        a/* args */,
  258.     Cardinal*        b/* num_args */,
  259.     XrmValuePtr        c/* fromVal */,
  260.     XrmValuePtr        d/* toVal */
  261. )
  262. {
  263. XmuCvtStringToBackingStore(a,b,c,d);
  264. }
  265.  
  266. static void
  267. ClassInitialize(void)
  268. {
  269.   XawInitializeWidgetSet();
  270.   XtAddConverter( XtRString, XtRBackingStore, relay_func,
  271.          NULL, 0 );
  272.   XmuAddInitializer( AddPositionAction, NULL);
  273. }
  274.  
  275. /*      Function Name: ClassInitialize
  276.  *      Description: Class Part Initialize routine, called for every
  277.  *                   subclass.  Makes sure that the subclasses pick up 
  278.  *                   the extension record.
  279.  *      Arguments: wc - the widget class of the subclass.
  280.  *      Returns: none.
  281.  */
  282.  
  283. static void
  284. ClassPartInitialize(WidgetClass wc)
  285. {
  286.     ComplexMenuWidgetClass cmwc = (ComplexMenuWidgetClass) wc;
  287.  
  288. /*
  289.  * Make sure that our subclass gets the extension rec too.
  290.  */
  291.  
  292.     extension_rec.next_extension = cmwc->composite_class.extension;
  293.     cmwc->composite_class.extension = (XtPointer) &extension_rec;
  294. }
  295.  
  296. /*      Function Name: Initialize
  297.  *      Description: Initializes the complex menu widget
  298.  *      Arguments: request - the widget requested by the argument list.
  299.  *                 new     - the new widget with both resource and non
  300.  *                           resource values.
  301.  *      Returns: none.
  302.  */
  303.  
  304. static void
  305. Initialize(Widget request unused, Widget new, ArgList args unused,
  306.     Cardinal *num_args unused)
  307. {
  308.   ComplexMenuWidget cmw = (ComplexMenuWidget) new;
  309.  
  310.   XmuCallInitializers(XtWidgetToApplicationContext(new));
  311.  
  312.   if (cmw->complex_menu.label_class == NULL) 
  313.       cmw->complex_menu.label_class = cmeBSBObjectClass;
  314.  
  315.   cmw->complex_menu.label = NULL;
  316.   cmw->complex_menu.entry_set = NULL;
  317.   cmw->complex_menu.prev_entry = NULL;
  318.   cmw->complex_menu.recursive_set_values = FALSE;
  319.  
  320.   if (cmw->complex_menu.label_string != NULL)
  321.       CreateLabel(new);
  322.  
  323.   cmw->complex_menu.menu_width = TRUE;
  324.  
  325.   if (cmw->core.width == 0) {
  326.       cmw->complex_menu.menu_width = FALSE;
  327.       cmw->core.width = GetMenuWidth(new, (Widget)NULL);
  328.   }
  329.  
  330.   cmw->complex_menu.menu_height = TRUE;
  331.  
  332.   if (cmw->core.height == 0) {
  333.       cmw->complex_menu.menu_height = FALSE;
  334.       cmw->core.height = GetMenuHeight(new);
  335.   }
  336.  
  337. /*
  338.  * Add a popup_callback routine for changing the cursor.
  339.  */
  340.   
  341.   XtAddCallback(new, XtNpopupCallback, ChangeCursorOnGrab, NULL);
  342.  
  343. /*
  344.  * Add a popdown_callback routine for clearing the parent field.
  345.  */
  346.   
  347.   XtAddCallback(new, XtNpopdownCallback, ClearParent, NULL);
  348. }
  349.  
  350. /*      Function Name: Redisplay
  351.  *      Description: Redisplays the contents of the widget.
  352.  *      Arguments: w - the complex menu widget.
  353.  *                 event - the X event that caused this redisplay.
  354.  *                 region - the region the needs to be repainted. 
  355.  *      Returns: none.
  356.  */
  357.  
  358. static void
  359. Redisplay(Widget w, XEvent *event unused, Region region)
  360. {
  361.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  362.     CmeObject * entry;
  363.     CmeObjectClass class;
  364.  
  365.     if (region == NULL)
  366.     XClearWindow(XtDisplay(w), XtWindow(w));
  367.  
  368.     /*
  369.      * Check and Paint each of the entries - including the label.
  370.      */
  371.  
  372.     ForAllChildren(cmw, entry) {
  373.     if (!XtIsManaged ( (Widget) *entry)) continue;
  374.  
  375.     if (region != NULL) 
  376.         switch(XRectInRegion(region, (int) (*entry)->rectangle.x,
  377.                  (int) (*entry)->rectangle.y,
  378.                  (unsigned int) (*entry)->rectangle.width,
  379.                  (unsigned int) (*entry)->rectangle.height)) {
  380.         case RectangleIn:
  381.         case RectanglePart:
  382.         break;
  383.         default:
  384.         continue;
  385.         }
  386.     class = (CmeObjectClass) (*entry)->object.widget_class;
  387.  
  388.     if (class->rect_class.expose != NULL)
  389.         (class->rect_class.expose)( (Widget) *entry, NULL, NULL);
  390.     }
  391. }
  392.  
  393. /*      Function Name: Realize
  394.  *      Description: Realizes the widget.
  395.  *      Arguments: w - the complex menu widget.
  396.  *                 mask - value mask for the window to create.
  397.  *                 attrs - attributes for the window to create.
  398.  *      Returns: none
  399.  */
  400.  
  401. static void
  402. Realize(Widget w, XtValueMask *mask, XSetWindowAttributes *attrs)
  403. {
  404.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  405.  
  406.     attrs->cursor = cmw->complex_menu.cursor;
  407.     *mask |= CWCursor;
  408.     if ((cmw->complex_menu.backing_store == Always) ||
  409.     (cmw->complex_menu.backing_store == NotUseful) ||
  410.     (cmw->complex_menu.backing_store == WhenMapped) ) {
  411.     *mask |= CWBackingStore;
  412.     attrs->backing_store = cmw->complex_menu.backing_store;
  413.     }
  414.     else
  415.     *mask &= ~CWBackingStore;
  416.  
  417.     (*def_superclass->core_class.realize) (w, mask, attrs);
  418. }
  419.  
  420. /*      Function Name: Resize
  421.  *      Description: Handle the menu being resized bigger.
  422.  *      Arguments: w - the complex menu widget.
  423.  *      Returns: none.
  424.  */
  425.  
  426. static void
  427. Resize(Widget w)
  428. {
  429.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  430.     CmeObject * entry;
  431.  
  432.     if ( !XtIsRealized(w) ) return;
  433.  
  434.     ForAllChildren(cmw, entry)     /* reset width of all entries. */
  435.     if (XtIsManaged( (Widget) *entry))
  436.         (*entry)->rectangle.width = cmw->core.width;
  437.     
  438.     Redisplay(w, (XEvent *) NULL, (Region) NULL);
  439. }
  440.  
  441. /*      Function Name: SetValues
  442.  *      Description: Relayout the menu when one of the resources is changed.
  443.  *      Arguments: current - current state of the widget.
  444.  *                 request - what was requested.
  445.  *                 new - what the widget will become.
  446.  *      Returns: none
  447.  */
  448.  
  449. static Boolean
  450. SetValues(Widget current, Widget request unused, Widget new,
  451.     ArgList args unused, Cardinal *num_args unused)
  452. {
  453.     ComplexMenuWidget cmw_old = (ComplexMenuWidget) current;
  454.     ComplexMenuWidget cmw_new = (ComplexMenuWidget) new;
  455.     Boolean ret_val = FALSE, layout = FALSE;
  456.     
  457.     if (!XtIsRealized(current)) return(FALSE);
  458.     
  459.     if (!cmw_new->complex_menu.recursive_set_values) {
  460.     if (cmw_new->core.width != cmw_old->core.width) {
  461.         cmw_new->complex_menu.menu_width = (cmw_new->core.width != 0);
  462.         layout = TRUE;
  463.     }
  464.     if (cmw_new->core.height != cmw_old->core.height) {
  465.         cmw_new->complex_menu.menu_height = (cmw_new->core.height != 0);
  466.         layout = TRUE;
  467.     }
  468.     }
  469.  
  470.     if (cmw_old->complex_menu.cursor != cmw_new->complex_menu.cursor)
  471.     XDefineCursor(XtDisplay(new),
  472.               XtWindow(new), cmw_new->complex_menu.cursor);
  473.     
  474.     if (cmw_old->complex_menu.label_string !=cmw_new->complex_menu.label_string) { 
  475.     if (cmw_new->complex_menu.label_string == NULL)         /* Destroy. */
  476.         XtDestroyWidget((Widget) cmw_old->complex_menu.label);
  477.     else if (cmw_old->complex_menu.label_string == NULL)    /* Create. */
  478.         CreateLabel(new);
  479.     else {                                                 /* Change. */
  480.         Arg arglist[1];
  481.         
  482.         XtSetArg(arglist[0], XtNlabel, cmw_new->complex_menu.label_string);
  483.         XtSetValues((Widget) cmw_new->complex_menu.label, arglist, ONE);
  484.     }
  485.     }
  486.     
  487.     if (cmw_old->complex_menu.label_class != cmw_new->complex_menu.label_class)
  488.     XtAppWarning(XtWidgetToApplicationContext(new),
  489.              "No Dynamic class change of the ComplexMenu Label.");
  490.     
  491.     if ((cmw_old->complex_menu.top_margin != cmw_new->complex_menu.top_margin) ||
  492.     (cmw_old->complex_menu.bottom_margin != 
  493.      cmw_new->complex_menu.bottom_margin) /* filler.................  */ ) {
  494.     layout = TRUE;
  495.     ret_val = TRUE;
  496.     }
  497.  
  498.     if (layout)
  499.     Layout(new, (Dimension *)NULL, (Dimension *)NULL);
  500.  
  501.     return(ret_val);
  502. }
  503.  
  504. /*      Function Name: SetValuesHook
  505.  *      Description: To handle a special case, this is passed the
  506.  *                   actual arguments.
  507.  *      Arguments: w - the menu widget.
  508.  *                 arglist - the argument list passed to XtSetValues.
  509.  *                 num_args - the number of args.
  510.  *      Returns: none
  511.  */
  512.  
  513. /* 
  514.  * If the user actually passed a width and height to the widget
  515.  * then this MUST be used, rather than our newly calculated width and
  516.  * height.
  517.  */
  518.  
  519. static Boolean
  520. SetValuesHook(Widget w, ArgList arglist, Cardinal *num_args)
  521. {
  522.     register Cardinal i;
  523.     Dimension width, height;
  524.     
  525.     width = w->core.width;
  526.     height = w->core.height;
  527.     
  528.     for ( i = 0 ; i < *num_args ; i++) {
  529.     if ( streq(arglist[i].name, XtNwidth) )
  530.         width = (Dimension) arglist[i].value;
  531.     if ( streq(arglist[i].name, XtNheight) )
  532.         height = (Dimension) arglist[i].value;
  533.     }
  534.  
  535.     if ((width != w->core.width) || (height != w->core.height))
  536.     MakeSetValuesRequest(w, width, height);
  537.     return(FALSE);
  538. }
  539.  
  540. /************************************************************
  541.  *
  542.  * Geometry Management routines.
  543.  *
  544.  ************************************************************/
  545.  
  546. /*    Function Name: GeometryManager
  547.  *    Description: This is the ComplexMenu Widget's Geometry Manager.
  548.  *    Arguments: w - the Menu Entry making the request.
  549.  *                 request - requested new geometry.
  550.  *                 reply - the allowed geometry.
  551.  *    Returns: XtGeometry{Yes, No, Almost}.
  552.  */
  553.  
  554. static XtGeometryResult
  555. GeometryManager(Widget w, XtWidgetGeometry *request, XtWidgetGeometry *reply)
  556. {
  557.     ComplexMenuWidget cmw = (ComplexMenuWidget) XtParent(w);
  558.     CmeObject entry = (CmeObject) w;
  559.     XtGeometryMask mode = request->request_mode;
  560.     XtGeometryResult answer;
  561.     Dimension old_height, old_width;
  562.  
  563.     if ( !(mode & CWWidth) && !(mode & CWHeight) )
  564.     return(XtGeometryNo);
  565.  
  566.     reply->width = request->width;
  567.     reply->height = request->height;
  568.  
  569.     old_width = entry->rectangle.width;
  570.     old_height = entry->rectangle.height;
  571.  
  572.     Layout(w, &(reply->width), &(reply->height) );
  573.  
  574. /*
  575.  * Since we are an override shell and have no parent there is no one to
  576.  * ask to see if this geom change is okay, so I am just going to assume
  577.  * we can do whatever we want.  If you subclass be very careful with this
  578.  * assumption, it could bite you.
  579.  *
  580.  * Chris D. Peterson - Sept. 1989.
  581.  */
  582.  
  583.     if ( (reply->width == request->width) &&
  584.      (reply->height == request->height) ) {
  585.  
  586.     if ( mode & XtCWQueryOnly ) { /* Actually perform the layout. */
  587.         entry->rectangle.width = old_width;
  588.         entry->rectangle.height = old_height;    
  589.     }
  590.     else {
  591.         Layout(( Widget) cmw, (Dimension *)NULL, (Dimension *)NULL);
  592.     }
  593.     answer = XtGeometryDone;
  594.     }
  595.     else {
  596.     entry->rectangle.width = old_width;
  597.     entry->rectangle.height = old_height;    
  598.  
  599.     if ( ((reply->width == request->width) && !(mode & CWHeight)) ||
  600.           ((reply->height == request->height) && !(mode & CWWidth)) ||
  601.           ((reply->width == request->width) && 
  602.            (reply->height == request->height)) )
  603.         answer = XtGeometryNo;
  604.     else {
  605.         answer = XtGeometryAlmost;
  606.         reply->request_mode = 0;
  607.         if (reply->width != request->width)
  608.         reply->request_mode |= CWWidth;
  609.         if (reply->height != request->height)
  610.         reply->request_mode |= CWHeight;
  611.     }
  612.     }
  613.     return(answer);
  614. }
  615.  
  616. /*    Function Name: ChangeManaged
  617.  *    Description: called whenever a new child is managed.
  618.  *    Arguments: w - the complex menu widget.
  619.  *    Returns: none.
  620.  */
  621.  
  622. static void
  623. ChangeManaged(Widget w)
  624. {
  625.     Layout(w, (Dimension *)NULL, (Dimension *)NULL);
  626. }
  627.  
  628. /************************************************************
  629.  *
  630.  * Global Action Routines.
  631.  * 
  632.  * These actions routines will be added to the application's
  633.  * global action list. 
  634.  * 
  635.  ************************************************************/
  636.  
  637. /*      Function Name: PositionMenuAction
  638.  *      Description: Positions the complex menu widget.
  639.  *      Arguments: w - a widget (no the complex menu widget.)
  640.  *                 event - the event that caused this action.
  641.  *                 params, num_params - parameters passed to the routine.
  642.  *                                      we expect the name of the menu here.
  643.  *      Returns: none
  644.  */
  645.  
  646. static void
  647. PositionMenuAction(Widget w, XEvent *event, String *params,
  648.     Cardinal *num_params)
  649. { 
  650.   Widget menu;
  651.   XPoint loc;
  652.  
  653.   if (*num_params != 1) {
  654.     char error_buf[BUFSIZ];
  655.     (void) sprintf(error_buf, "%s %s",
  656.         "Xaw - ComplexMenuWidget: position menu action expects only one",
  657.         "parameter which is the name of the menu.");
  658.     XtAppWarning(XtWidgetToApplicationContext(w), error_buf);
  659.     return;
  660.   }
  661.  
  662.   if ( (menu = FindMenu(w, params[0])) == NULL) {
  663.     char error_buf[BUFSIZ];
  664.     (void) sprintf(error_buf, "%s '%s'",
  665.         "Xaw - ComplexMenuWidget: could not find menu named: ", params[0]);
  666.     XtAppWarning(XtWidgetToApplicationContext(w), error_buf);
  667.     return;
  668.   }
  669.   
  670.   switch (event->type) {
  671.   case ButtonPress:
  672.   case ButtonRelease:
  673.     loc.x = event->xbutton.x_root;
  674.     loc.y = event->xbutton.y_root;
  675.     PositionMenu(menu, &loc);
  676.     break;
  677.   case EnterNotify:
  678.   case LeaveNotify:
  679.     loc.x = event->xcrossing.x_root;
  680.     loc.y = event->xcrossing.y_root;
  681.     PositionMenu(menu, &loc);
  682.     break;
  683.   case MotionNotify:
  684.     loc.x = event->xmotion.x_root;
  685.     loc.y = event->xmotion.y_root;
  686.     PositionMenu(menu, &loc);
  687.     break;
  688.   default:
  689.     PositionMenu(menu, (XPoint *)NULL);
  690.     break;
  691.   }
  692. }  
  693.  
  694. /************************************************************
  695.  *
  696.  * Widget Action Routines.
  697.  * 
  698.  ************************************************************/
  699.  
  700. /*      Function Name: Unhighlight
  701.  *      Description: Unhighlights current entry.
  702.  *      Arguments: w - the complex menu widget.
  703.  *                 event - the event that caused this action.
  704.  *                 params, num_params - ** NOT USED **
  705.  *      Returns: none
  706.  */
  707.  
  708. static void
  709. Unhighlight(Widget w, XEvent *event unused, String *params unused,
  710.     Cardinal *num_params unused)
  711. { 
  712.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  713.     CmeObject entry = cmw->complex_menu.entry_set;
  714.     CmeObjectClass class;
  715.  
  716.     if ( entry == NULL) return;
  717.  
  718.     cmw->complex_menu.entry_set = NULL;
  719.     class = (CmeObjectClass) entry->object.widget_class;
  720.     (class->cme_class.unhighlight) ( (Widget) entry);
  721. }
  722.  
  723. static void
  724. SaveUnhighlight(Widget w, XEvent *event unused, String *params unused,
  725.     Cardinal *num_params unused)
  726. { 
  727.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  728.     CmeObject entry = cmw->complex_menu.entry_set;
  729.     CmeObjectClass class;
  730.  
  731.     if ( entry == NULL) return;
  732.  
  733.     cmw->complex_menu.prev_entry = entry;
  734.     cmw->complex_menu.entry_set = NULL;
  735.     class = (CmeObjectClass) entry->object.widget_class;
  736.     (class->cme_class.unhighlight) ( (Widget) entry);
  737. }
  738.  
  739. /*      Function Name: LeftWindow
  740.  *      Description: Mouse has left window, usually this means unhighlight
  741.  *      Arguments: w - the complex menu widget.
  742.  *                 event - the event that caused this action.
  743.  *                 params, num_params - ** NOT USED **
  744.  *      Returns: none
  745.  */
  746.  
  747. static void
  748. LeftWindow(Widget w, XEvent *event, String *params unused,
  749.     Cardinal *num_params unused)
  750. { 
  751.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  752.     CmeObject entry = cmw->complex_menu.entry_set;
  753.     CmeObjectClass class;
  754.     String mn;
  755.  
  756.     if ( entry == NULL) return;
  757.  
  758.     mn = NULL;
  759.     XtVaGetValues((Widget) entry, XtNmenuName, &mn, NULL);
  760.     if (mn != NULL && GetRightEntry(w, event) == entry)
  761.     return;
  762.  
  763.     cmw->complex_menu.prev_entry = NULL;
  764.     cmw->complex_menu.entry_set = NULL;
  765.     class = (CmeObjectClass) entry->object.widget_class;
  766.     (class->cme_class.unhighlight) ( (Widget) entry);
  767. }
  768.  
  769. /*      Function Name: Highlight
  770.  *      Description: Highlights current entry.
  771.  *      Arguments: w - the complex menu widget.
  772.  *                 event - the event that caused this action.
  773.  *                 params, num_params - ** NOT USED **
  774.  *      Returns: none
  775.  */
  776.  
  777. static void
  778. Highlight(Widget w, XEvent *event, String *params, Cardinal *num_params)
  779. {
  780.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  781.     CmeObject entry;
  782.     CmeObjectClass class;
  783.     ShellWidget shell_widget = (ShellWidget)w;
  784.  
  785.     
  786. #if defined(CmeDebug)
  787.     printf("Highlight(%x)\n", w);
  788. #endif
  789.  
  790.     if (shell_widget->shell.popped_up != TRUE) {
  791. #if defined(CmeDebug)
  792.     printf("bogus\n");
  793. #endif
  794.     return;
  795.     }
  796.  
  797.     if ( !XtIsSensitive(w) ) return;
  798.     
  799.     entry = GetEventEntry(w, event);
  800.  
  801.     if (entry == cmw->complex_menu.entry_set) return;
  802.  
  803.     Unhighlight(w, event, params, num_params);  
  804.  
  805.     if (entry == NULL) return;
  806.  
  807.     if ( !XtIsSensitive( (Widget) entry)) {
  808.     cmw->complex_menu.entry_set = NULL;
  809.     return;
  810.     }
  811.  
  812.     cmw->complex_menu.entry_set = entry;
  813.     class = (CmeObjectClass) entry->object.widget_class;
  814.  
  815.     (class->cme_class.highlight) ( (Widget) entry);
  816. }
  817.  
  818. /*      Function Name: Notify
  819.  *      Description: Notify user of current entry.
  820.  *      Arguments: w - the complex menu widget.
  821.  *                 event - the event that caused this action.
  822.  *                 params, num_params - ** NOT USED **
  823.  *      Returns: none
  824.  */
  825.  
  826. static void
  827. Notify(Widget w, XEvent *event unused, String *params unused,
  828.     Cardinal *num_params unused)
  829. {
  830.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  831.     CmeObject entry = cmw->complex_menu.entry_set;
  832.     CmeObjectClass class;
  833.     
  834.     if (entry == NULL)
  835.     entry = cmw->complex_menu.prev_entry;
  836.     if ( (entry == NULL) || !XtIsSensitive((Widget) entry) ) return;
  837.  
  838.     if (cmw->complex_menu.parent != NULL) {
  839. #if defined(CmeDebug)
  840.     printf("Notify(%x): deferring to %x to parent %x\n", w, entry,
  841.         cmw->complex_menu.parent);
  842. #endif
  843.     XtVaSetValues(cmw->complex_menu.parent, XtNcMdefer, (Widget)entry,
  844.         NULL);
  845.     return;
  846.     }
  847. #if defined(CmeDebug)
  848.     else
  849.     printf("Notify(%x): not deferring\n", w);
  850. #endif
  851.     if (cmw->complex_menu.deferred_notify != NULL) {
  852. #if defined(CmeDebug)
  853.     printf("Notify: using deferred %x\n", w,
  854.         cmw->complex_menu.deferred_notify);
  855. #endif
  856.     entry = (CmeObject)cmw->complex_menu.deferred_notify;
  857.     }
  858.     class = (CmeObjectClass) entry->object.widget_class;
  859.     (class->cme_class.notify)( (Widget) entry );
  860. }
  861.  
  862. /************************************************************
  863.  *
  864.  * Public Functions.
  865.  *
  866.  ************************************************************/
  867.  
  868. /*    Function Name: XawComplexMenuAddGlobalActions
  869.  *    Description: adds the global actions to the complex menu widget.
  870.  *    Arguments: app_con - the appcontext.
  871.  *    Returns: none.
  872.  */
  873.  
  874. void
  875. XawComplexMenuAddGlobalActions(XtAppContext app_con)
  876. {
  877.     XtInitializeWidgetClass(complexMenuWidgetClass);
  878.     XmuCallInitializers( app_con );
  879. } 
  880.  
  881.  
  882. /*    Function Name: XawComplexMenuGetActiveEntry
  883.  *    Description: Gets the currently active (set) entry.
  884.  *    Arguments: w - the cmw widget.
  885.  *    Returns: the currently set entry or NULL if none is set.
  886.  */
  887.  
  888. Widget
  889. XawComplexMenuGetActiveEntry(Widget w)
  890. {
  891.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  892.  
  893.     return( (Widget) cmw->complex_menu.entry_set);
  894. } 
  895.  
  896. /*    Function Name: XawComplexMenuClearActiveEntry
  897.  *    Description: Unsets the currently active (set) entry.
  898.  *    Arguments: w - the cmw widget.
  899.  *    Returns: none.
  900.  */
  901.  
  902. void
  903. XawComplexMenuClearActiveEntry(Widget w)
  904. {
  905.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  906.  
  907.     cmw->complex_menu.entry_set = NULL;
  908.     cmw->complex_menu.prev_entry = NULL;
  909. } 
  910.  
  911. /************************************************************
  912.  *
  913.  * Private Functions.
  914.  *
  915.  ************************************************************/
  916.  
  917. /*    Function Name: CreateLabel
  918.  *    Description: Creates a the menu label.
  919.  *    Arguments: w - the cmw widget.
  920.  *    Returns: none.
  921.  * 
  922.  * Creates the label object and makes sure it is the first child in
  923.  * in the list.
  924.  */
  925.  
  926. static void
  927. CreateLabel(Widget w)
  928. {
  929.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  930.     register Widget * child, * next_child;
  931.     register int i;
  932.     Arg args[2];
  933.  
  934.     if ( (cmw->complex_menu.label_string == NULL) ||
  935.      (cmw->complex_menu.label != NULL) ) {
  936.     char error_buf[BUFSIZ];
  937.  
  938.     (void) sprintf(error_buf, "Xaw Complex Menu Widget: %s or %s, %s",
  939.         "label string is NULL", "label already exists", 
  940.         "no label is being created.");
  941.     XtAppWarning(XtWidgetToApplicationContext(w), error_buf);
  942.     return;
  943.     }
  944.  
  945.     XtSetArg(args[0], XtNlabel, cmw->complex_menu.label_string);
  946.     XtSetArg(args[1], XtNjustify, XtJustifyCenter);
  947.     cmw->complex_menu.label = (CmeObject) 
  948.                           XtCreateManagedWidget("menuLabel", 
  949.                         cmw->complex_menu.label_class, w,
  950.                         args, TWO);
  951.  
  952.     next_child = NULL;
  953.     for (child = cmw->composite.children + cmw->composite.num_children,
  954.      i = cmw->composite.num_children ; i > 0 ; i--, child--) {
  955.     if (next_child != NULL)
  956.         *next_child = *child;
  957.     next_child = child;
  958.     }
  959.     *child = (Widget) cmw->complex_menu.label;
  960. }
  961.  
  962. /*    Function Name: Layout
  963.  *    Description: lays the menu entries out all nice and neat.
  964.  *    Arguments: w - See below (+++)
  965.  *                 width_ret, height_ret - The returned width and 
  966.  *                                         height values.
  967.  *    Returns: none.
  968.  *
  969.  * if width == NULL || height == NULL then it assumes the you do not care
  970.  * about the return values, and just want a relayout.
  971.  *
  972.  * if this is not the case then it will set width_ret and height_ret
  973.  * to be width and height that the child would get if it were layed out
  974.  * at this time.
  975.  *
  976.  * +++ "w" can be the complex menu widget or any of its object children.
  977.  */
  978.  
  979. static void
  980. Layout(Widget w, Dimension *width_ret, Dimension *height_ret)
  981. {
  982.     CmeObject current_entry, *entry;
  983.     ComplexMenuWidget cmw;
  984.     Dimension width, height;
  985.     Boolean do_layout = ((height_ret == NULL) || (width_ret == NULL));
  986.     Boolean allow_change_size;
  987.     height = 0;
  988.  
  989.     if ( XtIsSubclass(w, complexMenuWidgetClass) ) {
  990.     cmw = (ComplexMenuWidget) w;
  991.     current_entry = NULL;
  992.     }
  993.     else {
  994.     cmw = (ComplexMenuWidget) XtParent(w);
  995.     current_entry = (CmeObject) w;
  996.     }
  997.  
  998.     allow_change_size = (!XtIsRealized((Widget)cmw) ||
  999.              (cmw->shell.allow_shell_resize));
  1000.  
  1001.     if ( cmw->complex_menu.menu_height )
  1002.     height = cmw->core.height;
  1003.     else
  1004.     if (do_layout) {
  1005.         height = cmw->complex_menu.top_margin;
  1006.         ForAllChildren(cmw, entry) {
  1007.         if (!XtIsManaged( (Widget) *entry)) continue;
  1008.  
  1009.         if ( (cmw->complex_menu.row_height != 0) && 
  1010.             (*entry != cmw->complex_menu.label) ) 
  1011.             (*entry)->rectangle.height = cmw->complex_menu.row_height;
  1012.         
  1013.         (*entry)->rectangle.y = height;
  1014.         (*entry)->rectangle.x = 0;
  1015.         height += (*entry)->rectangle.height;
  1016.         }
  1017.         height += cmw->complex_menu.bottom_margin;
  1018.     }
  1019.     else {
  1020.         if ((cmw->complex_menu.row_height != 0) && 
  1021.         (current_entry != cmw->complex_menu.label) )
  1022.         height = cmw->complex_menu.row_height;
  1023.     }
  1024.     
  1025.     if (cmw->complex_menu.menu_width)
  1026.     width = cmw->core.width;
  1027.     else if ( allow_change_size )
  1028.     width = GetMenuWidth((Widget) cmw, (Widget) current_entry);
  1029.     else
  1030.     width = cmw->core.width;
  1031.  
  1032.     if (do_layout) {
  1033.     ForAllChildren(cmw, entry)
  1034.         if (XtIsManaged( (Widget) *entry)) 
  1035.         (*entry)->rectangle.width = width;
  1036.  
  1037.     if (allow_change_size)
  1038.         MakeSetValuesRequest((Widget) cmw, width, height);
  1039.     }
  1040.     else {
  1041.     *width_ret = width;
  1042.     if (height != 0)
  1043.         *height_ret = height;
  1044.     }
  1045. }
  1046.     
  1047. /*    Function Name: AddPositionAction
  1048.  *    Description: Adds the XawPositionComplexMenu action to the global
  1049.  *                   action list for this appcon.
  1050.  *    Arguments: app_con - the application context for this app.
  1051.  *                 data - NOT USED.
  1052.  *    Returns: none.
  1053.  */
  1054.  
  1055. static void
  1056. AddPositionAction(XtAppContext app_con, caddr_t data unused)
  1057. {
  1058.     static XtActionsRec pos_action[] = {
  1059.         { "XawPositionComplexMenu", PositionMenuAction },
  1060.     };
  1061.  
  1062.     XtAppAddActions(app_con, pos_action, XtNumber(pos_action));
  1063. }
  1064.  
  1065. /*    Function Name: FindMenu
  1066.  *    Description: Find the menu give a name and reference widget.
  1067.  *    Arguments: widget - reference widget.
  1068.  *                 name   - the menu widget's name.
  1069.  *    Returns: the menu widget or NULL.
  1070.  */
  1071.  
  1072. static Widget 
  1073. FindMenu(Widget widget, String name)
  1074. {
  1075.     register Widget w, menu;
  1076.     
  1077.     for ( w = widget ; w != NULL ; w = XtParent(w) )
  1078.     if ( (menu = XtNameToWidget(w, name)) != NULL )
  1079.         return(menu);
  1080.     return(NULL);
  1081. }
  1082.  
  1083. /*    Function Name: PositionMenu
  1084.  *    Description: Places the menu
  1085.  *    Arguments: w - the complex menu widget.
  1086.  *                 location - a pointer the the position or NULL.
  1087.  *    Returns: none.
  1088.  */
  1089.  
  1090. static void
  1091. PositionMenu(Widget w, XPoint *location)
  1092. {
  1093.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  1094.     CmeObject entry;
  1095.     XPoint t_point;
  1096.     
  1097.     if (location == NULL) {
  1098.     Window junk1, junk2;
  1099.     int root_x, root_y, junkX, junkY;
  1100.     unsigned int junkM;
  1101.     
  1102.     location = &t_point;
  1103.     if (XQueryPointer(XtDisplay(w), XtWindow(w), &junk1, &junk2, 
  1104.               &root_x, &root_y, &junkX, &junkY, &junkM) == FALSE) {
  1105.         char error_buf[BUFSIZ];
  1106.         (void) sprintf(error_buf, "%s %s", "Xaw - ComplexMenuWidget:",
  1107.             "Could not find location of mouse pointer");
  1108.         XtAppWarning(XtWidgetToApplicationContext(w), error_buf);
  1109.         return;
  1110.     }
  1111.     location->x = (short) root_x;
  1112.     location->y = (short) root_y;
  1113.     }
  1114.     
  1115.     /*
  1116.      * The width will not be correct unless it is realized.
  1117.      */
  1118.     
  1119.     XtRealizeWidget(w);
  1120.     
  1121.     location->x -= (Position) w->core.width/2;
  1122.     
  1123.     if (cmw->complex_menu.popup_entry == NULL)
  1124.     entry = cmw->complex_menu.label;
  1125.     else
  1126.     entry = cmw->complex_menu.popup_entry;
  1127.  
  1128.     if (entry != NULL)
  1129.     location->y -= entry->rectangle.y + entry->rectangle.height/2;
  1130.  
  1131.     MoveMenu(w, (Position) location->x, (Position) location->y);
  1132. }
  1133.  
  1134. /*    Function Name: MoveMenu
  1135.  *    Description: Actually moves the menu, may force it to
  1136.  *                   to be fully visable if menu_on_screen is TRUE.
  1137.  *    Arguments: w - the complex menu widget.
  1138.  *                 x, y - the current location of the widget.
  1139.  *    Returns: none 
  1140.  */
  1141.  
  1142. static void
  1143. MoveMenu(Widget w, Position x, Position y)
  1144. {
  1145.     Arg arglist[2];
  1146.     Cardinal num_args = 0;
  1147.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  1148.     
  1149.     if (cmw->complex_menu.menu_on_screen) {
  1150.     int width = w->core.width + 2 * w->core.border_width;
  1151.     int height = w->core.height + 2 * w->core.border_width;
  1152.     
  1153.     if (x >= 0) {
  1154.         int scr_width = WidthOfScreen(XtScreen(w));
  1155.         if (x + width > scr_width)
  1156.         x = scr_width - width;
  1157.     }
  1158.     if (x < 0) 
  1159.         x = 0;
  1160.     
  1161.     if (y >= 0) {
  1162.         int scr_height = HeightOfScreen(XtScreen(w));
  1163.         if (y + height > scr_height)
  1164.         y = scr_height - height;
  1165.     }
  1166.     if (y < 0)
  1167.         y = 0;
  1168.     }
  1169.     
  1170.     XtSetArg(arglist[num_args], XtNx, x); num_args++;
  1171.     XtSetArg(arglist[num_args], XtNy, y); num_args++;
  1172.     XtSetValues(w, arglist, num_args);
  1173. }
  1174.  
  1175. /*    Function Name: ChangeCursorOnGrab
  1176.  *    Description: Changes the cursor on the active grab to the one
  1177.  *                   specified in out resource list.
  1178.  *    Arguments: w - the widget.
  1179.  *                 junk, garbage - ** NOT USED **.
  1180.  *    Returns: None.
  1181.  */
  1182.  
  1183. static void
  1184. ChangeCursorOnGrab(Widget w, XtPointer junk unused, XtPointer garbage unused)
  1185. {
  1186.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  1187.     
  1188. #if defined(CmeDebug)
  1189.     printf("ChangeCursorOnGrab(%x): parent=%x\n", w, cmw->complex_menu.parent);
  1190. #endif
  1191.     cmw->complex_menu.deferred_notify = NULL;
  1192.     cmw->complex_menu.prev_entry = NULL;
  1193.     
  1194.     /*
  1195.      * The event mask here is what is currently in the MIT implementation.
  1196.      * There really needs to be a way to get the value of the mask out
  1197.      * of the toolkit (CDP 5/26/89).
  1198.      */
  1199.     
  1200.     XChangeActivePointerGrab(XtDisplay(w), ButtonPressMask|ButtonReleaseMask,
  1201.                  cmw->complex_menu.cursor, 
  1202.                  XtLastTimestampProcessed(XtDisplay(w)));
  1203. }
  1204.  
  1205. static void
  1206. ClearParent(Widget w, XtPointer junk unused, XtPointer garbage unused)
  1207. {
  1208.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  1209.     
  1210. #if defined(CmeDebug)
  1211.     printf("ClearParent(%x): parent=%x\n", w, cmw->complex_menu.parent);
  1212. #endif
  1213.     Notify(w, (XEvent *)NULL, (String *)NULL, (Cardinal *)NULL);
  1214.     cmw->complex_menu.parent = NULL;
  1215. }
  1216.  
  1217. /*      Function Name: MakeSetValuesRequest
  1218.  *      Description: Makes a (possibly recursive) call to SetValues,
  1219.  *                   I take great pains to not go into an infinite loop.
  1220.  *      Arguments: w - the complex menu widget.
  1221.  *                 width, height - the size of the ask for.
  1222.  *      Returns: none
  1223.  */
  1224.  
  1225. static void
  1226. MakeSetValuesRequest(Widget w, Dimension width, Dimension height)
  1227. {
  1228.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  1229.     Arg arglist[2];
  1230.     Cardinal num_args = (Cardinal) 0;
  1231.     
  1232.     if ( !cmw->complex_menu.recursive_set_values ) {
  1233.     if ( (cmw->core.width != width) || (cmw->core.height != height) ) {
  1234.         cmw->complex_menu.recursive_set_values = TRUE;
  1235.         XtSetArg(arglist[num_args], XtNwidth, width);   num_args++;
  1236.         XtSetArg(arglist[num_args], XtNheight, height); num_args++;
  1237.         XtSetValues(w, arglist, num_args);
  1238.     }
  1239.     else if (XtIsRealized( (Widget) cmw))
  1240.         Redisplay((Widget) cmw, (XEvent *) NULL, (Region) NULL);
  1241.     }
  1242.     cmw->complex_menu.recursive_set_values = FALSE;
  1243. }
  1244.  
  1245. /*      Function Name: GetMenuWidth
  1246.  *      Description: Sets the length of the widest entry in pixels.
  1247.  *      Arguments: w - the complex menu widget.
  1248.  *      Returns: width of menu.
  1249.  */
  1250.  
  1251. static Dimension
  1252. GetMenuWidth(Widget w, Widget w_ent)
  1253. {
  1254.     CmeObject cur_entry = (CmeObject) w_ent;
  1255.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  1256.     Dimension width, widest = (Dimension) 0;
  1257.     CmeObject * entry;
  1258.     
  1259.     if ( cmw->complex_menu.menu_width ) 
  1260.     return(cmw->core.width);
  1261.  
  1262.     ForAllChildren(cmw, entry) {
  1263.     XtWidgetGeometry preferred;
  1264.  
  1265.     if (!XtIsManaged( (Widget) *entry)) continue;
  1266.     
  1267.     if (*entry != cur_entry) {
  1268.         XtQueryGeometry((Widget) *entry, NULL, &preferred);
  1269.         
  1270.         if (preferred.request_mode & CWWidth)
  1271.         width = preferred.width;
  1272.         else
  1273.         width = (*entry)->rectangle.width;
  1274.     }
  1275.     else
  1276.         width = (*entry)->rectangle.width;
  1277.     
  1278.     if ( width > widest )
  1279.         widest = width;
  1280.     }
  1281.     
  1282.     return(widest);
  1283. }
  1284.  
  1285. /*      Function Name: GetMenuHeight
  1286.  *      Description: Sets the length of the widest entry in pixels.
  1287.  *      Arguments: w - the complex menu widget.
  1288.  *      Returns: width of menu.
  1289.  */
  1290.  
  1291. static Dimension
  1292. GetMenuHeight(Widget w)
  1293. {
  1294.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  1295.     CmeObject * entry;
  1296.     Dimension height;
  1297.     
  1298.     if (cmw->complex_menu.menu_height)
  1299.     return(cmw->core.height);
  1300.  
  1301.     height = cmw->complex_menu.top_margin + cmw->complex_menu.bottom_margin;
  1302.     
  1303.     if (cmw->complex_menu.row_height == 0) {
  1304.     ForAllChildren(cmw, entry) 
  1305.         if (XtIsManaged ((Widget) *entry)) 
  1306.         height += (*entry)->rectangle.height;
  1307.     } else 
  1308.     height += cmw->complex_menu.row_height * cmw->composite.num_children;
  1309.     
  1310.     return(height);
  1311. }
  1312.  
  1313. /*      Function Name: GetEventEntry
  1314.  *      Description: Gets an entry given an event that has X and Y coords.
  1315.  *      Arguments: w - the complex menu widget.
  1316.  *                 event - the event.
  1317.  *      Returns: the entry that this point is in.
  1318.  */
  1319.  
  1320. static CmeObject
  1321. GetEventEntry(Widget w, XEvent *event)
  1322. {
  1323.     Position x_loc = 0, y_loc = 0;
  1324.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  1325.     CmeObject * entry;
  1326.     
  1327.     switch (event->type) {
  1328.     case MotionNotify:
  1329.     x_loc = event->xmotion.x;
  1330.     y_loc = event->xmotion.y;
  1331.     break;
  1332.     case EnterNotify:
  1333.     case LeaveNotify:
  1334.     x_loc = event->xcrossing.x;
  1335.     y_loc = event->xcrossing.y;
  1336.     break;
  1337.     case ButtonPress:
  1338.     case ButtonRelease:
  1339.     x_loc = event->xbutton.x;
  1340.     y_loc = event->xbutton.y;
  1341.     break;
  1342.     default:
  1343.     XtAppError(XtWidgetToApplicationContext(w),
  1344.            "Unknown event type in GetEventEntry().");
  1345.     break;
  1346.     }
  1347.     
  1348.     if ( (x_loc < 0) || (x_loc >= (int)cmw->core.width) || (y_loc < 0) ||
  1349.     (y_loc >= (int)cmw->core.height) )
  1350.     return(NULL);
  1351.     
  1352.     ForAllChildren(cmw, entry) {
  1353.     if (!XtIsManaged ((Widget) *entry)) continue;
  1354.  
  1355.     if ( ((*entry)->rectangle.y < y_loc) &&
  1356.             ((*entry)->rectangle.y + (int) (*entry)->rectangle.height > y_loc) ) {
  1357.         if ( *entry == cmw->complex_menu.label )
  1358.         return(NULL);    /* cannot select the label. */
  1359.         else
  1360.         return(*entry);
  1361.         }
  1362.     }
  1363.     
  1364.     return(NULL);
  1365. }
  1366.  
  1367. /*      Function Name: GetRightEntry
  1368.  *      Description: Gets an entry given a crossing event that has X and Y
  1369.  *                   coords, unless it exited to the right.
  1370.  *      Arguments: w - the complex menu widget.
  1371.  *                 event - the event.
  1372.  *      Returns: the entry that this point is in.
  1373.  */
  1374.  
  1375. static CmeObject
  1376. GetRightEntry(Widget w, XEvent *event)
  1377. {
  1378.     Position x_loc, y_loc;
  1379.     ComplexMenuWidget cmw = (ComplexMenuWidget) w;
  1380.     CmeObject * entry;
  1381.  
  1382.     x_loc = event->xcrossing.x;
  1383.     y_loc = event->xcrossing.y;
  1384.  
  1385.     if ( (x_loc < 0) || /*(x_loc < (int)cmw->core.width) ||*/ (y_loc < 0) ||
  1386.     (y_loc >= (int)cmw->core.height) )
  1387.     return(NULL);
  1388.  
  1389.     ForAllChildren(cmw, entry) {
  1390.     if (!XtIsManaged ((Widget) *entry)) continue;
  1391.  
  1392.     if ( ((*entry)->rectangle.y < y_loc) &&
  1393.             ((*entry)->rectangle.y + (int) (*entry)->rectangle.height > y_loc) ) {
  1394.         if ( *entry == cmw->complex_menu.label )
  1395.         return(NULL);    /* cannot select the label. */
  1396.         else
  1397.         return(*entry);
  1398.         }
  1399.     }
  1400.  
  1401.     return(NULL);
  1402. }
  1403.  
  1404. #endif /*]*/
  1405.